﻿using Song.Common.Tools;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections;
using System.Data;

namespace Test.Unit
{
    
    
    /// <summary>
    ///This is a test class for EnumerableExtensionsTest and is intended
    ///to contain all EnumerableExtensionsTest Unit Tests
    ///</summary>
    [TestClass()]
    public class EnumerableExtensionsTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for AsReadOnly
        ///</summary>
        public void AsReadOnlyTestHelper<T>()
        {
            IEnumerable<T> @this = null; // TODO: Initialize to an appropriate value
            ReadOnlyCollection<T> expected = null; // TODO: Initialize to an appropriate value
            ReadOnlyCollection<T> actual;
            actual = EnumerableExtensions.AsReadOnly<T>(@this);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void AsReadOnlyTest()
        {
            AsReadOnlyTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Concat
        ///</summary>
        public void ConcatTestHelper<TSource>()
        {
            IEnumerator<TSource> left = null; // TODO: Initialize to an appropriate value
            IEnumerator<TSource> right = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> actual;
            actual = EnumerableExtensions.Concat<TSource>(left, right);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ConcatTest()
        {
            ConcatTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Concat
        ///</summary>
        public void ConcatTest1Helper<TSource>()
        {
            IEnumerator<TSource> left = null; // TODO: Initialize to an appropriate value
            TSource last = default(TSource); // TODO: Initialize to an appropriate value
            IEnumerable<TSource> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> actual;
            actual = EnumerableExtensions.Concat<TSource>(left, last);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ConcatTest1()
        {
            ConcatTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Concat
        ///</summary>
        public void ConcatTest2Helper<TSource>()
        {
            TSource first = default(TSource); // TODO: Initialize to an appropriate value
            IEnumerator<TSource> right = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> actual;
            actual = EnumerableExtensions.Concat<TSource>(first, right);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ConcatTest2()
        {
            ConcatTest2Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Constructor
        ///</summary>
        public void ConstructorTestHelper<T>()
            where T : class
        {
            IEnumerable<object> parameters = null; // TODO: Initialize to an appropriate value
            IDictionary<string, object> properties = null; // TODO: Initialize to an appropriate value
            T expected = null; // TODO: Initialize to an appropriate value
            T actual;
            actual = EnumerableExtensions.Constructor<T>(parameters, properties);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ConstructorTest()
        {
            ConstructorTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Contains
        ///</summary>
        public void ContainsTestHelper<T>()
        {
            IEnumerable<T> items = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = EnumerableExtensions.Contains<T>(items, value);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ContainsTest()
        {
            ContainsTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ContainsAtLeast
        ///</summary>
        public void ContainsAtLeastTestHelper<T>()
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            int count = 0; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = EnumerableExtensions.ContainsAtLeast<T>(enumeration, count);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ContainsAtLeastTest()
        {
            ContainsAtLeastTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Do
        ///</summary>
        public void DoTestHelper<TSource>()
        {
            IEnumerable<TSource> source = null; // TODO: Initialize to an appropriate value
            Action<TSource> action = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> actual;
            actual = EnumerableExtensions.Do<TSource>(source, action);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void DoTest()
        {
            DoTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Do
        ///</summary>
        public void DoTest1Helper<TSource>()
        {
            IEnumerable<TSource> source = null; // TODO: Initialize to an appropriate value
            Action<TSource, int> action = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<TSource> actual;
            actual = EnumerableExtensions.Do<TSource>(source, action);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void DoTest1()
        {
            DoTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Do
        ///</summary>
        [TestMethod()]
        public void DoTest2()
        {
            IEnumerable source = null; // TODO: Initialize to an appropriate value
            Action<object, int> action = null; // TODO: Initialize to an appropriate value
            IEnumerable expected = null; // TODO: Initialize to an appropriate value
            IEnumerable actual;
            actual = EnumerableExtensions.Do(source, action);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for Do
        ///</summary>
        [TestMethod()]
        public void DoTest3()
        {
            IEnumerable source = null; // TODO: Initialize to an appropriate value
            Action<object> action = null; // TODO: Initialize to an appropriate value
            IEnumerable expected = null; // TODO: Initialize to an appropriate value
            IEnumerable actual;
            actual = EnumerableExtensions.Do(source, action);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for Flatten
        ///</summary>
        [TestMethod()]
        public void FlattenTest()
        {
            IEnumerable inputs = null; // TODO: Initialize to an appropriate value
            Func<object, IEnumerable> enumerate = null; // TODO: Initialize to an appropriate value
            IEnumerable expected = null; // TODO: Initialize to an appropriate value
            IEnumerable actual;
            actual = EnumerableExtensions.Flatten(inputs, enumerate);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for Flatten
        ///</summary>
        public void FlattenTest1Helper<T>()
            where T : class
        {
            IEnumerable<T> inputs = null; // TODO: Initialize to an appropriate value
            Func<T, IEnumerable<T>> enumerate = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.Flatten<T>(inputs, enumerate);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void FlattenTest1()
        {
            FlattenTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ForEach
        ///</summary>
        public void ForEachTestHelper<T>()
        {
            IEnumerable<T> items = null; // TODO: Initialize to an appropriate value
            Action<T> odd = null; // TODO: Initialize to an appropriate value
            Action<T> even = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.ForEach<T>(items, odd, even);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ForEachTest()
        {
            ForEachTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ForEach
        ///</summary>
        public void ForEachTest1Helper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Action<T> action = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.ForEach<T>(source, action);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ForEachTest1()
        {
            ForEachTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GroupEvery
        ///</summary>
        public void GroupEveryTestHelper<T>()
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            int count = 0; // TODO: Initialize to an appropriate value
            IEnumerable<T[]> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T[]> actual;
            actual = EnumerableExtensions.GroupEvery<T>(enumeration, count);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void GroupEveryTest()
        {
            GroupEveryTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for In
        ///</summary>
        public void InTestHelper<T>()
            where T : IEquatable<T>
        {
            T source = default(T); // TODO: Initialize to an appropriate value
            IEnumerable<T> values = null; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = EnumerableExtensions.In<T>(source, values);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void InTest()
        {
            Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
                    "Please call InTestHelper<T>() with appropriate type parameters.");
        }

        /// <summary>
        ///A test for IndexOf
        ///</summary>
        public void IndexOfTestHelper<T>()
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            IEqualityComparer<T> comparer = null; // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = EnumerableExtensions.IndexOf<T>(enumeration, value, comparer);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IndexOfTest()
        {
            IndexOfTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for IndexOf
        ///</summary>
        public void IndexOfTest1Helper<T>()
            where T : IEquatable<T>
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = EnumerableExtensions.IndexOf<T>(enumeration, value);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IndexOfTest1()
        {
            Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
                    "Please call IndexOfTest1Helper<T>() with appropriate type parameters.");
        }

        /// <summary>
        ///A test for IndexOf
        ///</summary>
        public void IndexOfTest2Helper<T>()
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            int startIndex = 0; // TODO: Initialize to an appropriate value
            IEqualityComparer<T> comparer = null; // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = EnumerableExtensions.IndexOf<T>(enumeration, value, startIndex, comparer);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IndexOfTest2()
        {
            IndexOfTest2Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for IndexOf
        ///</summary>
        public void IndexOfTest3Helper<T>()
            where T : IEquatable<T>
        {
            IEnumerable<T> enumeration = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            int startIndex = 0; // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = EnumerableExtensions.IndexOf<T>(enumeration, value, startIndex);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IndexOfTest3()
        {
            Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
                    "Please call IndexOfTest3Helper<T>() with appropriate type parameters.");
        }

        /// <summary>
        ///A test for IndexOfPrevious
        ///</summary>
        public void IndexOfPreviousTestHelper<T>()
        {
            IEnumerable<T> items = null; // TODO: Initialize to an appropriate value
            T value = default(T); // TODO: Initialize to an appropriate value
            int fromIndex = 0; // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = EnumerableExtensions.IndexOfPrevious<T>(items, value, fromIndex);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IndexOfPreviousTest()
        {
            IndexOfPreviousTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for IsNullEmpty
        ///</summary>
        [TestMethod()]
        public void IsNullEmptyTest()
        {
            IEnumerable source = null; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = EnumerableExtensions.IsNullEmpty(source);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for MergeWith
        ///</summary>
        public void MergeWithTestHelper<T>()
        {
            IEnumerable<T> target = null; // TODO: Initialize to an appropriate value
            IEnumerable<T>[] data = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.MergeWith<T>(target, data);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void MergeWithTest()
        {
            MergeWithTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Partition
        ///</summary>
        public void PartitionTestHelper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            int size = 0; // TODO: Initialize to an appropriate value
            IEnumerable<IEnumerable<T>> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<IEnumerable<T>> actual;
            actual = EnumerableExtensions.Partition<T>(source, size);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void PartitionTest()
        {
            PartitionTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Slice
        ///</summary>
        public void SliceTestHelper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Nullable<int> start = new Nullable<int>(); // TODO: Initialize to an appropriate value
            Nullable<int> stop = new Nullable<int>(); // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.Slice<T>(source, start, stop);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void SliceTest()
        {
            SliceTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Slice
        ///</summary>
        public void SliceTest1Helper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Nullable<int> start = new Nullable<int>(); // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.Slice<T>(source, start);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void SliceTest1()
        {
            SliceTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Slice
        ///</summary>
        public void SliceTest2Helper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Nullable<int> start = new Nullable<int>(); // TODO: Initialize to an appropriate value
            Nullable<int> stop = new Nullable<int>(); // TODO: Initialize to an appropriate value
            Nullable<int> step = new Nullable<int>(); // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.Slice<T>(source, start, stop, step);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void SliceTest2()
        {
            SliceTest2Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ToDataTable
        ///</summary>
        public void ToDataTableTestHelper<T>()
        {
            IEnumerable<T> varlist = null; // TODO: Initialize to an appropriate value
            DataTable expected = null; // TODO: Initialize to an appropriate value
            DataTable actual;
            actual = EnumerableExtensions.ToDataTable<T>(varlist);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ToDataTableTest()
        {
            ToDataTableTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ToJson
        ///</summary>
        public void ToJsonTestHelper<TSource, TResult>()
        {
            IEnumerable<TSource> varlist = null; // TODO: Initialize to an appropriate value
            Func<TSource, TResult> selector = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = EnumerableExtensions.ToJson<TSource, TResult>(varlist, selector);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ToJsonTest()
        {
            ToJsonTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ToPage
        ///</summary>
        public void ToPageTestHelper<TSource>()
        {
            IEnumerable<TSource> varlist = null; // TODO: Initialize to an appropriate value
            int pageIndex = 0; // TODO: Initialize to an appropriate value
            int pageSize = 0; // TODO: Initialize to an appropriate value
            int totalRecords = 0; // TODO: Initialize to an appropriate value
            int totalRecordsExpected = 0; // TODO: Initialize to an appropriate value
            List<TSource> expected = null; // TODO: Initialize to an appropriate value
            List<TSource> actual;
            actual = EnumerableExtensions.ToPage<TSource>(varlist, pageIndex, pageSize, out totalRecords);
            Assert.AreEqual(totalRecordsExpected, totalRecords);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ToPageTest()
        {
            ToPageTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for WhereIf
        ///</summary>
        public void WhereIfTestHelper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Func<T, bool> predicate = null; // TODO: Initialize to an appropriate value
            bool condition = false; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.WhereIf<T>(source, predicate, condition);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void WhereIfTest()
        {
            WhereIfTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for WhereIf
        ///</summary>
        public void WhereIfTest1Helper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            Func<T, int, bool> predicate = null; // TODO: Initialize to an appropriate value
            bool condition = false; // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.WhereIf<T>(source, predicate, condition);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void WhereIfTest1()
        {
            WhereIfTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for With
        ///</summary>
        public void WithTestHelper<T>()
        {
            IEnumerable<T> source = null; // TODO: Initialize to an appropriate value
            T item = default(T); // TODO: Initialize to an appropriate value
            IEnumerable<T> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<T> actual;
            actual = EnumerableExtensions.With<T>(source, item);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void WithTest()
        {
            WithTestHelper<GenericParameterHelper>();
        }
    }
}
